emain/emain-tabview.ts (1)

96-110: Consider adding error handling for edge cases.

While the implementation is solid, consider handling these edge cases:

1. Multiple rapid calls to setKeyboardChordMode(true)
2. Potential memory leaks if component is destroyed while timeout is pending

 setKeyboardChordMode(mode: boolean) {
     this.keyboardChordMode = mode;
     if (mode) {
         if (this.resetChordModeTimeout) {
             clearTimeout(this.resetChordModeTimeout);
+            this.resetChordModeTimeout = null;
         }
         this.resetChordModeTimeout = setTimeout(() => {
             this.keyboardChordMode = false;
+            this.resetChordModeTimeout = null;
         }, 2000);
     } else {
         if (this.resetChordModeTimeout) {
             clearTimeout(this.resetChordModeTimeout);
+            this.resetChordModeTimeout = null;
         }
     }
 }

frontend/app/store/keymodel.ts (2)

36-41: Consider adding documentation for chord state management.

The chord-related variables would benefit from JSDoc comments explaining:

• Purpose and structure of globalChordMap
• Lifecycle of activeChord and chordTimeout

+/** Map storing chord key combinations and their associated handlers */
 const globalChordMap = new Map<string, Map<string, KeyHandler>>();

+/** Current active chord key combination */
 let activeChord: string | null = null;
+/** Timeout for resetting the active chord state */
 let chordTimeout: NodeJS.Timeout = null;

---

42-56: Consider adding error handling for edge cases.

The chord management functions should handle edge cases:

1. Multiple rapid chord attempts
2. Concurrent timeouts

 function resetChord() {
+    // Clear any existing chord state
     activeChord = null;
     if (chordTimeout) {
         clearTimeout(chordTimeout);
         chordTimeout = null;
     }
 }

 function setActiveChord(activeChordArg: string) {
+    if (!activeChordArg) {
+        return;
+    }
     if (chordTimeout) {
         clearTimeout(chordTimeout);
     }
     activeChord = activeChordArg;
     chordTimeout = setTimeout(() => resetChord(), 2000);
 }

docs/docs/keybindings.mdx (1)

18-18: Enhance chord documentation with examples and timeout behavior.

The chord timing documentation is clear but could be more helpful with additional details:

• Add an example of a chord sequence (e.g., "For example, to split a block above, press Ctrl+Shift+s followed by ArrowUp within 2 seconds")
• Explain what happens if the second key is not pressed within 2 seconds

Configuration used: CodeRabbit UI
Review profile: CHILL
Plan: Pro

frontend/app/store/keymodel.ts (4)

32-37: Consider extracting chord configuration.

The chord implementation looks good, but consider extracting the timeout duration (2000ms) into a configuration constant for better maintainability.

+const CHORD_TIMEOUT_MS = 2000;
 type KeyHandler = (event: WaveKeyboardEvent) => boolean;

 const simpleControlShiftAtom = jotai.atom(false);
 const globalKeyMap = new Map<string, (waveEvent: WaveKeyboardEvent) => boolean>();
 const globalChordMap = new Map<string, Map<string, KeyHandler>>();

---

245-263: Consider reducing duplication in split functions.

The handleSplitHorizontal and handleSplitVertical functions share almost identical structure. Consider extracting the common logic into a shared helper function.

+async function handleSplit(
+    direction: "horizontal" | "vertical",
+    position: "before" | "after"
+) {
+    const layoutModel = getLayoutModelForStaticTab();
+    const focusedNode = globalStore.get(layoutModel.focusedNode);
+    if (focusedNode == null) {
+        return;
+    }
+    const blockDef = getDefaultNewBlockDef();
+    await (direction === "horizontal"
+        ? createBlockSplitHorizontally
+        : createBlockSplitVertically)(blockDef, focusedNode.data.blockId, position);
+}
+
-async function handleSplitHorizontal(position: "before" | "after") {
-    const layoutModel = getLayoutModelForStaticTab();
-    const focusedNode = globalStore.get(layoutModel.focusedNode);
-    if (focusedNode == null) {
-        return;
-    }
-    const blockDef = getDefaultNewBlockDef();
-    await createBlockSplitHorizontally(blockDef, focusedNode.data.blockId, position);
+async function handleSplitHorizontal(position: "before" | "after") {
+    return handleSplit("horizontal", position);
 }

-async function handleSplitVertical(position: "before" | "after") {
-    const layoutModel = getLayoutModelForStaticTab();
-    const focusedNode = globalStore.get(layoutModel.focusedNode);
-    if (focusedNode == null) {
-        return;
-    }
-    const blockDef = getDefaultNewBlockDef();
-    await createBlockSplitVertically(blockDef, focusedNode.data.blockId, position);
+async function handleSplitVertical(position: "before" | "after") {
+    return handleSplit("vertical", position);
 }

---

281-281: Remove debug console.log statements.

These debug logs should be removed or replaced with proper logging utility for production code.

-        console.log("lastHandledEvent return false");
-        console.log("handle activeChord", activeChord);
+        // Consider using a logging utility if debugging is needed in production

Also applies to: 286-286

---

444-455: Reuse launcher block definition.

Consider reusing the launcher block definition from getDefaultNewBlockDef to maintain consistency and reduce duplication.

     globalKeyMap.set("Ctrl:Shift:k", () => {
         const blockId = getFocusedBlockId();
         if (blockId == null) {
             return true;
         }
-        replaceBlock(blockId, {
-            meta: {
-                view: "launcher",
-            },
-        });
+        const launcherDef = getDefaultNewBlockDef();
+        launcherDef.meta.view = "launcher";
+        replaceBlock(blockId, launcherDef);
         return true;
     });

Configuration used: CodeRabbit UI
Review profile: CHILL
Plan: Pro

emain/emain-tabview.ts (2)

96-111: Consider improvements to the keyboard chord mode implementation.

While the implementation is functional, consider these enhancements:

1. Extract the timeout duration (2000ms) to a named constant for better maintainability
2. Simplify the timeout cleanup in the 'else' block
3. Add JSDoc documentation to describe the method's purpose and parameters

Apply this diff to implement the suggested improvements:

+const KEYBOARD_CHORD_MODE_TIMEOUT_MS = 2000;
+
+/**
+ * Sets the keyboard chord mode state and manages its auto-reset timeout.
+ * @param mode - When true, enables chord mode and sets a timeout to disable it.
+ *               When false, immediately disables chord mode and cleans up the timeout.
+ */
 setKeyboardChordMode(mode: boolean) {
     this.keyboardChordMode = mode;
     if (mode) {
         if (this.resetChordModeTimeout) {
             clearTimeout(this.resetChordModeTimeout);
         }
         this.resetChordModeTimeout = setTimeout(() => {
             this.keyboardChordMode = false;
-        }, 2000);
+        }, KEYBOARD_CHORD_MODE_TIMEOUT_MS);
     } else {
-        if (this.resetChordModeTimeout) {
-            clearTimeout(this.resetChordModeTimeout);
-            this.resetChordModeTimeout = null;
-        }
+        clearTimeout(this.resetChordModeTimeout);
+        this.resetChordModeTimeout = null;
     }
 }

---

242-246: Add documentation for keyboard chord mode handling.

The implementation correctly handles keyboard events in chord mode, but would benefit from documentation explaining the behavior.

Add a comment to explain the chord mode handling:

+        // In chord mode, prevent the default key behavior, disable chord mode,
+        // and reinject the key event to be handled by the renderer process
         if (input.type == "keyDown" && tabView.keyboardChordMode) {
             e.preventDefault();
             tabView.setKeyboardChordMode(false);
             tabView.webContents.send("reinject-key", waveEvent);
         }

Configuration used: CodeRabbit UI
Review profile: CHILL
Plan: Pro